package cn.shopping.core.daomanager.immutable;

import cn.shopping.common.daomanager.CommonDaoManager;
import cn.shopping.core.dbo.UploadInfoDO;
import org.springframework.util.CollectionUtils;

import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;


/**
 * 代码自动生成，请不要修改，切记！！！
 */
public interface ImmutableUploadInfoDaoManager extends CommonDaoManager<UploadInfoDO,Long> {


        public List<UploadInfoDO> listByOriginalFileName(String originalFileName, String... fieldNames);

        public Map<Long,UploadInfoDO> mapByOriginalFileName(String originalFileName, String... fieldNames);

        public Integer countByOriginalFileName(String originalFileName);

        public default UploadInfoDO singleResultByOriginalFileName(String originalFileName,String... fieldNames){
             List<UploadInfoDO> list=this.listByOriginalFileName(originalFileName,fieldNames);
             return CollectionUtils.isEmpty(list)?null:list.get(0);
        }

         public default <T> Map<T,List<UploadInfoDO>> groupingByOriginalFileName(String originalFileName, Function<UploadInfoDO, T> mapper, String... fieldNames){
             List<UploadInfoDO> list=this.listByOriginalFileName(originalFileName,fieldNames);
             if(CollectionUtils.isEmpty(list)){
                return new HashMap<>();
             }
             return list.stream().collect(Collectors.groupingBy(mapper));
         }

        public Integer updateNotNullFieldsByOriginalFileName(UploadInfoDO updateDO, String originalFileName);

        public Integer updateAllFieldsByOriginalFileName(UploadInfoDO updateDO,  String originalFileName);

        public Integer deleteByOriginalFileName( String originalFileName);






        public List<UploadInfoDO> listByInOriginalFileName(Collection<String> originalFileNameList, String... fieldNames);

         public Map<Long,UploadInfoDO> mapByInOriginalFileName(Collection<String> originalFileNameList, String... fieldNames);

         public Integer countByInOriginalFileName(Collection<String> originalFileNameList);

         public default UploadInfoDO singleResultByInOriginalFileName(Collection<String> originalFileNameList,String... fieldNames){
              List<UploadInfoDO> list=this.listByInOriginalFileName(originalFileNameList,fieldNames);
              return CollectionUtils.isEmpty(list)?null:list.get(0);
         }

          public default <T> Map<T,List<UploadInfoDO>> groupingByInOriginalFileName(Collection<String> originalFileNameList, Function<UploadInfoDO, T> mapper, String... fieldNames){
              List<UploadInfoDO> list=this.listByInOriginalFileName(originalFileNameList,fieldNames);
              if(CollectionUtils.isEmpty(list)){
                 return new HashMap<>();
              }
              return list.stream().collect(Collectors.groupingBy(mapper));
          }

         public Integer updateNotNullFieldsByInOriginalFileName(UploadInfoDO updateDO, Collection<String> originalFileNameList);

         public Integer updateAllFieldsByInOriginalFileName(UploadInfoDO updateDO,  Collection<String> originalFileNameList);

         public Integer deleteByInOriginalFileName( Collection<String> originalFileNameList);
        public List<UploadInfoDO> listByFileName(String fileName, String... fieldNames);

        public Map<Long,UploadInfoDO> mapByFileName(String fileName, String... fieldNames);

        public Integer countByFileName(String fileName);

        public default UploadInfoDO singleResultByFileName(String fileName,String... fieldNames){
             List<UploadInfoDO> list=this.listByFileName(fileName,fieldNames);
             return CollectionUtils.isEmpty(list)?null:list.get(0);
        }

         public default <T> Map<T,List<UploadInfoDO>> groupingByFileName(String fileName, Function<UploadInfoDO, T> mapper, String... fieldNames){
             List<UploadInfoDO> list=this.listByFileName(fileName,fieldNames);
             if(CollectionUtils.isEmpty(list)){
                return new HashMap<>();
             }
             return list.stream().collect(Collectors.groupingBy(mapper));
         }

        public Integer updateNotNullFieldsByFileName(UploadInfoDO updateDO, String fileName);

        public Integer updateAllFieldsByFileName(UploadInfoDO updateDO,  String fileName);

        public Integer deleteByFileName( String fileName);






        public List<UploadInfoDO> listByInFileName(Collection<String> fileNameList, String... fieldNames);

         public Map<Long,UploadInfoDO> mapByInFileName(Collection<String> fileNameList, String... fieldNames);

         public Integer countByInFileName(Collection<String> fileNameList);

         public default UploadInfoDO singleResultByInFileName(Collection<String> fileNameList,String... fieldNames){
              List<UploadInfoDO> list=this.listByInFileName(fileNameList,fieldNames);
              return CollectionUtils.isEmpty(list)?null:list.get(0);
         }

          public default <T> Map<T,List<UploadInfoDO>> groupingByInFileName(Collection<String> fileNameList, Function<UploadInfoDO, T> mapper, String... fieldNames){
              List<UploadInfoDO> list=this.listByInFileName(fileNameList,fieldNames);
              if(CollectionUtils.isEmpty(list)){
                 return new HashMap<>();
              }
              return list.stream().collect(Collectors.groupingBy(mapper));
          }

         public Integer updateNotNullFieldsByInFileName(UploadInfoDO updateDO, Collection<String> fileNameList);

         public Integer updateAllFieldsByInFileName(UploadInfoDO updateDO,  Collection<String> fileNameList);

         public Integer deleteByInFileName( Collection<String> fileNameList);
        public List<UploadInfoDO> listByFileSuffix(String fileSuffix, String... fieldNames);

        public Map<Long,UploadInfoDO> mapByFileSuffix(String fileSuffix, String... fieldNames);

        public Integer countByFileSuffix(String fileSuffix);

        public default UploadInfoDO singleResultByFileSuffix(String fileSuffix,String... fieldNames){
             List<UploadInfoDO> list=this.listByFileSuffix(fileSuffix,fieldNames);
             return CollectionUtils.isEmpty(list)?null:list.get(0);
        }

         public default <T> Map<T,List<UploadInfoDO>> groupingByFileSuffix(String fileSuffix, Function<UploadInfoDO, T> mapper, String... fieldNames){
             List<UploadInfoDO> list=this.listByFileSuffix(fileSuffix,fieldNames);
             if(CollectionUtils.isEmpty(list)){
                return new HashMap<>();
             }
             return list.stream().collect(Collectors.groupingBy(mapper));
         }

        public Integer updateNotNullFieldsByFileSuffix(UploadInfoDO updateDO, String fileSuffix);

        public Integer updateAllFieldsByFileSuffix(UploadInfoDO updateDO,  String fileSuffix);

        public Integer deleteByFileSuffix( String fileSuffix);






        public List<UploadInfoDO> listByInFileSuffix(Collection<String> fileSuffixList, String... fieldNames);

         public Map<Long,UploadInfoDO> mapByInFileSuffix(Collection<String> fileSuffixList, String... fieldNames);

         public Integer countByInFileSuffix(Collection<String> fileSuffixList);

         public default UploadInfoDO singleResultByInFileSuffix(Collection<String> fileSuffixList,String... fieldNames){
              List<UploadInfoDO> list=this.listByInFileSuffix(fileSuffixList,fieldNames);
              return CollectionUtils.isEmpty(list)?null:list.get(0);
         }

          public default <T> Map<T,List<UploadInfoDO>> groupingByInFileSuffix(Collection<String> fileSuffixList, Function<UploadInfoDO, T> mapper, String... fieldNames){
              List<UploadInfoDO> list=this.listByInFileSuffix(fileSuffixList,fieldNames);
              if(CollectionUtils.isEmpty(list)){
                 return new HashMap<>();
              }
              return list.stream().collect(Collectors.groupingBy(mapper));
          }

         public Integer updateNotNullFieldsByInFileSuffix(UploadInfoDO updateDO, Collection<String> fileSuffixList);

         public Integer updateAllFieldsByInFileSuffix(UploadInfoDO updateDO,  Collection<String> fileSuffixList);

         public Integer deleteByInFileSuffix( Collection<String> fileSuffixList);
        public List<UploadInfoDO> listByFilePath(String filePath, String... fieldNames);

        public Map<Long,UploadInfoDO> mapByFilePath(String filePath, String... fieldNames);

        public Integer countByFilePath(String filePath);

        public default UploadInfoDO singleResultByFilePath(String filePath,String... fieldNames){
             List<UploadInfoDO> list=this.listByFilePath(filePath,fieldNames);
             return CollectionUtils.isEmpty(list)?null:list.get(0);
        }

         public default <T> Map<T,List<UploadInfoDO>> groupingByFilePath(String filePath, Function<UploadInfoDO, T> mapper, String... fieldNames){
             List<UploadInfoDO> list=this.listByFilePath(filePath,fieldNames);
             if(CollectionUtils.isEmpty(list)){
                return new HashMap<>();
             }
             return list.stream().collect(Collectors.groupingBy(mapper));
         }

        public Integer updateNotNullFieldsByFilePath(UploadInfoDO updateDO, String filePath);

        public Integer updateAllFieldsByFilePath(UploadInfoDO updateDO,  String filePath);

        public Integer deleteByFilePath( String filePath);






        public List<UploadInfoDO> listByInFilePath(Collection<String> filePathList, String... fieldNames);

         public Map<Long,UploadInfoDO> mapByInFilePath(Collection<String> filePathList, String... fieldNames);

         public Integer countByInFilePath(Collection<String> filePathList);

         public default UploadInfoDO singleResultByInFilePath(Collection<String> filePathList,String... fieldNames){
              List<UploadInfoDO> list=this.listByInFilePath(filePathList,fieldNames);
              return CollectionUtils.isEmpty(list)?null:list.get(0);
         }

          public default <T> Map<T,List<UploadInfoDO>> groupingByInFilePath(Collection<String> filePathList, Function<UploadInfoDO, T> mapper, String... fieldNames){
              List<UploadInfoDO> list=this.listByInFilePath(filePathList,fieldNames);
              if(CollectionUtils.isEmpty(list)){
                 return new HashMap<>();
              }
              return list.stream().collect(Collectors.groupingBy(mapper));
          }

         public Integer updateNotNullFieldsByInFilePath(UploadInfoDO updateDO, Collection<String> filePathList);

         public Integer updateAllFieldsByInFilePath(UploadInfoDO updateDO,  Collection<String> filePathList);

         public Integer deleteByInFilePath( Collection<String> filePathList);
        public List<UploadInfoDO> listByFileSize(Long fileSize, String... fieldNames);

        public Map<Long,UploadInfoDO> mapByFileSize(Long fileSize, String... fieldNames);

        public Integer countByFileSize(Long fileSize);

        public default UploadInfoDO singleResultByFileSize(Long fileSize,String... fieldNames){
             List<UploadInfoDO> list=this.listByFileSize(fileSize,fieldNames);
             return CollectionUtils.isEmpty(list)?null:list.get(0);
        }

         public default <T> Map<T,List<UploadInfoDO>> groupingByFileSize(Long fileSize, Function<UploadInfoDO, T> mapper, String... fieldNames){
             List<UploadInfoDO> list=this.listByFileSize(fileSize,fieldNames);
             if(CollectionUtils.isEmpty(list)){
                return new HashMap<>();
             }
             return list.stream().collect(Collectors.groupingBy(mapper));
         }

        public Integer updateNotNullFieldsByFileSize(UploadInfoDO updateDO, Long fileSize);

        public Integer updateAllFieldsByFileSize(UploadInfoDO updateDO,  Long fileSize);

        public Integer deleteByFileSize( Long fileSize);






        public List<UploadInfoDO> listByInFileSize(Collection<Long> fileSizeList, String... fieldNames);

         public Map<Long,UploadInfoDO> mapByInFileSize(Collection<Long> fileSizeList, String... fieldNames);

         public Integer countByInFileSize(Collection<Long> fileSizeList);

         public default UploadInfoDO singleResultByInFileSize(Collection<Long> fileSizeList,String... fieldNames){
              List<UploadInfoDO> list=this.listByInFileSize(fileSizeList,fieldNames);
              return CollectionUtils.isEmpty(list)?null:list.get(0);
         }

          public default <T> Map<T,List<UploadInfoDO>> groupingByInFileSize(Collection<Long> fileSizeList, Function<UploadInfoDO, T> mapper, String... fieldNames){
              List<UploadInfoDO> list=this.listByInFileSize(fileSizeList,fieldNames);
              if(CollectionUtils.isEmpty(list)){
                 return new HashMap<>();
              }
              return list.stream().collect(Collectors.groupingBy(mapper));
          }

         public Integer updateNotNullFieldsByInFileSize(UploadInfoDO updateDO, Collection<Long> fileSizeList);

         public Integer updateAllFieldsByInFileSize(UploadInfoDO updateDO,  Collection<Long> fileSizeList);

         public Integer deleteByInFileSize( Collection<Long> fileSizeList);
        public List<UploadInfoDO> listByUploadUserId(Long uploadUserId, String... fieldNames);

        public Map<Long,UploadInfoDO> mapByUploadUserId(Long uploadUserId, String... fieldNames);

        public Integer countByUploadUserId(Long uploadUserId);

        public default UploadInfoDO singleResultByUploadUserId(Long uploadUserId,String... fieldNames){
             List<UploadInfoDO> list=this.listByUploadUserId(uploadUserId,fieldNames);
             return CollectionUtils.isEmpty(list)?null:list.get(0);
        }

         public default <T> Map<T,List<UploadInfoDO>> groupingByUploadUserId(Long uploadUserId, Function<UploadInfoDO, T> mapper, String... fieldNames){
             List<UploadInfoDO> list=this.listByUploadUserId(uploadUserId,fieldNames);
             if(CollectionUtils.isEmpty(list)){
                return new HashMap<>();
             }
             return list.stream().collect(Collectors.groupingBy(mapper));
         }

        public Integer updateNotNullFieldsByUploadUserId(UploadInfoDO updateDO, Long uploadUserId);

        public Integer updateAllFieldsByUploadUserId(UploadInfoDO updateDO,  Long uploadUserId);

        public Integer deleteByUploadUserId( Long uploadUserId);






        public List<UploadInfoDO> listByInUploadUserId(Collection<Long> uploadUserIdList, String... fieldNames);

         public Map<Long,UploadInfoDO> mapByInUploadUserId(Collection<Long> uploadUserIdList, String... fieldNames);

         public Integer countByInUploadUserId(Collection<Long> uploadUserIdList);

         public default UploadInfoDO singleResultByInUploadUserId(Collection<Long> uploadUserIdList,String... fieldNames){
              List<UploadInfoDO> list=this.listByInUploadUserId(uploadUserIdList,fieldNames);
              return CollectionUtils.isEmpty(list)?null:list.get(0);
         }

          public default <T> Map<T,List<UploadInfoDO>> groupingByInUploadUserId(Collection<Long> uploadUserIdList, Function<UploadInfoDO, T> mapper, String... fieldNames){
              List<UploadInfoDO> list=this.listByInUploadUserId(uploadUserIdList,fieldNames);
              if(CollectionUtils.isEmpty(list)){
                 return new HashMap<>();
              }
              return list.stream().collect(Collectors.groupingBy(mapper));
          }

         public Integer updateNotNullFieldsByInUploadUserId(UploadInfoDO updateDO, Collection<Long> uploadUserIdList);

         public Integer updateAllFieldsByInUploadUserId(UploadInfoDO updateDO,  Collection<Long> uploadUserIdList);

         public Integer deleteByInUploadUserId( Collection<Long> uploadUserIdList);
        public List<UploadInfoDO> listByFileDetail(String fileDetail, String... fieldNames);

        public Map<Long,UploadInfoDO> mapByFileDetail(String fileDetail, String... fieldNames);

        public Integer countByFileDetail(String fileDetail);

        public default UploadInfoDO singleResultByFileDetail(String fileDetail,String... fieldNames){
             List<UploadInfoDO> list=this.listByFileDetail(fileDetail,fieldNames);
             return CollectionUtils.isEmpty(list)?null:list.get(0);
        }

         public default <T> Map<T,List<UploadInfoDO>> groupingByFileDetail(String fileDetail, Function<UploadInfoDO, T> mapper, String... fieldNames){
             List<UploadInfoDO> list=this.listByFileDetail(fileDetail,fieldNames);
             if(CollectionUtils.isEmpty(list)){
                return new HashMap<>();
             }
             return list.stream().collect(Collectors.groupingBy(mapper));
         }

        public Integer updateNotNullFieldsByFileDetail(UploadInfoDO updateDO, String fileDetail);

        public Integer updateAllFieldsByFileDetail(UploadInfoDO updateDO,  String fileDetail);

        public Integer deleteByFileDetail( String fileDetail);






        public List<UploadInfoDO> listByInFileDetail(Collection<String> fileDetailList, String... fieldNames);

         public Map<Long,UploadInfoDO> mapByInFileDetail(Collection<String> fileDetailList, String... fieldNames);

         public Integer countByInFileDetail(Collection<String> fileDetailList);

         public default UploadInfoDO singleResultByInFileDetail(Collection<String> fileDetailList,String... fieldNames){
              List<UploadInfoDO> list=this.listByInFileDetail(fileDetailList,fieldNames);
              return CollectionUtils.isEmpty(list)?null:list.get(0);
         }

          public default <T> Map<T,List<UploadInfoDO>> groupingByInFileDetail(Collection<String> fileDetailList, Function<UploadInfoDO, T> mapper, String... fieldNames){
              List<UploadInfoDO> list=this.listByInFileDetail(fileDetailList,fieldNames);
              if(CollectionUtils.isEmpty(list)){
                 return new HashMap<>();
              }
              return list.stream().collect(Collectors.groupingBy(mapper));
          }

         public Integer updateNotNullFieldsByInFileDetail(UploadInfoDO updateDO, Collection<String> fileDetailList);

         public Integer updateAllFieldsByInFileDetail(UploadInfoDO updateDO,  Collection<String> fileDetailList);

         public Integer deleteByInFileDetail( Collection<String> fileDetailList);
        public List<UploadInfoDO> listByUserIdCreate(Long userIdCreate, String... fieldNames);

        public Map<Long,UploadInfoDO> mapByUserIdCreate(Long userIdCreate, String... fieldNames);

        public Integer countByUserIdCreate(Long userIdCreate);

        public default UploadInfoDO singleResultByUserIdCreate(Long userIdCreate,String... fieldNames){
             List<UploadInfoDO> list=this.listByUserIdCreate(userIdCreate,fieldNames);
             return CollectionUtils.isEmpty(list)?null:list.get(0);
        }

         public default <T> Map<T,List<UploadInfoDO>> groupingByUserIdCreate(Long userIdCreate, Function<UploadInfoDO, T> mapper, String... fieldNames){
             List<UploadInfoDO> list=this.listByUserIdCreate(userIdCreate,fieldNames);
             if(CollectionUtils.isEmpty(list)){
                return new HashMap<>();
             }
             return list.stream().collect(Collectors.groupingBy(mapper));
         }

        public Integer updateNotNullFieldsByUserIdCreate(UploadInfoDO updateDO, Long userIdCreate);

        public Integer updateAllFieldsByUserIdCreate(UploadInfoDO updateDO,  Long userIdCreate);

        public Integer deleteByUserIdCreate( Long userIdCreate);






        public List<UploadInfoDO> listByInUserIdCreate(Collection<Long> userIdCreateList, String... fieldNames);

         public Map<Long,UploadInfoDO> mapByInUserIdCreate(Collection<Long> userIdCreateList, String... fieldNames);

         public Integer countByInUserIdCreate(Collection<Long> userIdCreateList);

         public default UploadInfoDO singleResultByInUserIdCreate(Collection<Long> userIdCreateList,String... fieldNames){
              List<UploadInfoDO> list=this.listByInUserIdCreate(userIdCreateList,fieldNames);
              return CollectionUtils.isEmpty(list)?null:list.get(0);
         }

          public default <T> Map<T,List<UploadInfoDO>> groupingByInUserIdCreate(Collection<Long> userIdCreateList, Function<UploadInfoDO, T> mapper, String... fieldNames){
              List<UploadInfoDO> list=this.listByInUserIdCreate(userIdCreateList,fieldNames);
              if(CollectionUtils.isEmpty(list)){
                 return new HashMap<>();
              }
              return list.stream().collect(Collectors.groupingBy(mapper));
          }

         public Integer updateNotNullFieldsByInUserIdCreate(UploadInfoDO updateDO, Collection<Long> userIdCreateList);

         public Integer updateAllFieldsByInUserIdCreate(UploadInfoDO updateDO,  Collection<Long> userIdCreateList);

         public Integer deleteByInUserIdCreate( Collection<Long> userIdCreateList);
        public List<UploadInfoDO> listByUserIdModified(Long userIdModified, String... fieldNames);

        public Map<Long,UploadInfoDO> mapByUserIdModified(Long userIdModified, String... fieldNames);

        public Integer countByUserIdModified(Long userIdModified);

        public default UploadInfoDO singleResultByUserIdModified(Long userIdModified,String... fieldNames){
             List<UploadInfoDO> list=this.listByUserIdModified(userIdModified,fieldNames);
             return CollectionUtils.isEmpty(list)?null:list.get(0);
        }

         public default <T> Map<T,List<UploadInfoDO>> groupingByUserIdModified(Long userIdModified, Function<UploadInfoDO, T> mapper, String... fieldNames){
             List<UploadInfoDO> list=this.listByUserIdModified(userIdModified,fieldNames);
             if(CollectionUtils.isEmpty(list)){
                return new HashMap<>();
             }
             return list.stream().collect(Collectors.groupingBy(mapper));
         }

        public Integer updateNotNullFieldsByUserIdModified(UploadInfoDO updateDO, Long userIdModified);

        public Integer updateAllFieldsByUserIdModified(UploadInfoDO updateDO,  Long userIdModified);

        public Integer deleteByUserIdModified( Long userIdModified);






        public List<UploadInfoDO> listByInUserIdModified(Collection<Long> userIdModifiedList, String... fieldNames);

         public Map<Long,UploadInfoDO> mapByInUserIdModified(Collection<Long> userIdModifiedList, String... fieldNames);

         public Integer countByInUserIdModified(Collection<Long> userIdModifiedList);

         public default UploadInfoDO singleResultByInUserIdModified(Collection<Long> userIdModifiedList,String... fieldNames){
              List<UploadInfoDO> list=this.listByInUserIdModified(userIdModifiedList,fieldNames);
              return CollectionUtils.isEmpty(list)?null:list.get(0);
         }

          public default <T> Map<T,List<UploadInfoDO>> groupingByInUserIdModified(Collection<Long> userIdModifiedList, Function<UploadInfoDO, T> mapper, String... fieldNames){
              List<UploadInfoDO> list=this.listByInUserIdModified(userIdModifiedList,fieldNames);
              if(CollectionUtils.isEmpty(list)){
                 return new HashMap<>();
              }
              return list.stream().collect(Collectors.groupingBy(mapper));
          }

         public Integer updateNotNullFieldsByInUserIdModified(UploadInfoDO updateDO, Collection<Long> userIdModifiedList);

         public Integer updateAllFieldsByInUserIdModified(UploadInfoDO updateDO,  Collection<Long> userIdModifiedList);

         public Integer deleteByInUserIdModified( Collection<Long> userIdModifiedList);


}

